// 暂时没用到的服务，为了使上位机上场，做临时回复
package robot

import (
	"context"
	"time"

	"device-admin/internal/app/grpc/protoc/robotc"
)

func (s *Server) C2S(context.Context, *robotc.ReqMsg) (*robotc.RspMsg, error) {
	return &robotc.RspMsg{Ret: ""}, nil
}

func (s *Server) C2SV2(context.Context, *robotc.ReqMsg2) (*robotc.RspMsg2, error) {
	return &robotc.RspMsg2{Ret: ""}, nil
}

func (s *Server) C2SS(in *robotc.RegMsg, ss robotc.BaseService_C2SSServer) error {
	for {
		select {
		case <-ss.Context().Done():
			return nil
		default:
			time.Sleep(time.Second * 10)
		}
	}
}

func (s *Server) C2SSV2(in *robotc.RegMsg2, ss robotc.BaseService_C2SSV2Server) error {
	for {
		select {
		case <-ss.Context().Done():
			return nil
		default:
			time.Sleep(time.Second * 10)
		}
	}
}

func (s *Server) C2S_WILD(ctx context.Context, ss *robotc.WildMsg) (*robotc.WildMsg, error) {
	return ss, nil
}

func (s *Server) C2SS_WILD(in *robotc.WildMsg, ss robotc.BaseService_C2SS_WILDServer) error {
	for {
		select {
		case <-ss.Context().Done():
			return nil
		default:
			time.Sleep(time.Second * 10)
		}
	}
}

func (s *Server) RaDarWorkState2Server(context.Context, *robotc.NotifyRadarWorkState) (*robotc.RspRadarWorkState, error) {
	return &robotc.RspRadarWorkState{NVoid: 1}, nil
}

func (s *Server) PathLineAngular2Client(in *robotc.PathLineAngularCMDParam, ss robotc.BaseService_PathLineAngular2ClientServer) error {
	for {
		select {
		case <-ss.Context().Done():
			return nil
		default:
			time.Sleep(time.Second * 10)
		}
	}
}

func (s *Server) PathLineAngularC2Srsp(context.Context, *robotc.RspPathLineAngularClient2Server) (*robotc.ReqPathLineAngularServer2Client, error) {
	return &robotc.ReqPathLineAngularServer2Client{StrMsg: ""}, nil
}

func (s *Server) ABTask2Client(in *robotc.RspRunSpecificPoint, ss robotc.BaseService_ABTask2ClientServer) error {
	for {
		select {
		case <-ss.Context().Done():
			return nil
		default:
			time.Sleep(time.Second * 10)
		}
	}
}

func (s *Server) ABTaskC2Srsp(context.Context, *robotc.RspABTask2ClientC2S) (*robotc.ReqABTask2ClientS2C, error) {
	return &robotc.ReqABTask2ClientS2C{NVoid: 1}, nil
}

func (s *Server) SetOperateSpeed2Client(in *robotc.SetOperateSpeedCMDParam, ss robotc.BaseService_SetOperateSpeed2ClientServer) error {
	for {
		select {
		case <-ss.Context().Done():
			return nil
		default:
			time.Sleep(time.Second * 10)
		}
	}
}

func (s *Server) SetCollectModeC2Srsp(context.Context, *robotc.RspCollectMode2ClientC2S) (*robotc.ReqCollectMode2ClientS2C, error) {
	return &robotc.ReqCollectMode2ClientS2C{NVoid: 1}, nil
}

func (s *Server) ModifyMapNameCMD2Client(in *robotc.ModifyMapNameCMDParam, ss robotc.BaseService_ModifyMapNameCMD2ClientServer) error {
	for {
		select {
		case <-ss.Context().Done():
			return nil
		default:
			time.Sleep(time.Second * 10)
		}
	}
}

func (s *Server) ModifyMapNameC2Srsp(context.Context, *robotc.RspModifyMapNameC2S) (*robotc.ReqModifyMapNameS2C, error) {
	return &robotc.ReqModifyMapNameS2C{NVoid: 1}, nil
}

func (s *Server) DeleteMapC2Srsp(context.Context, *robotc.RspDeleteMapC2S) (*robotc.ReqDeleteMapS2C, error) {
	return &robotc.ReqDeleteMapS2C{NVoid: 1}, nil
}

func (s *Server) CreatePathCMD2Client(in *robotc.CreatePathCMDParam, ss robotc.BaseService_CreatePathCMD2ClientServer) error {
	for {
		select {
		case <-ss.Context().Done():
			return nil
		default:
			time.Sleep(time.Second * 10)
		}
	}
}

func (s *Server) CreatePathC2Srsp(context.Context, *robotc.RspCreatePathC2S) (*robotc.ReqCreatePathS2C, error) {
	return &robotc.ReqCreatePathS2C{NVoid: 1}, nil
}

func (s *Server) ModifyPathPointCMD2Client(in *robotc.ModifyPathPointCMDParam, ss robotc.BaseService_ModifyPathPointCMD2ClientServer) error {
	for {
		select {
		case <-ss.Context().Done():
			return nil
		default:
			time.Sleep(time.Second * 10)
		}
	}
}

func (s *Server) ModifyPathPointC2Srsp(context.Context, *robotc.RspModifyPathPointC2S) (*robotc.ReqModifyPathPointS2C, error) {
	return &robotc.ReqModifyPathPointS2C{NVoid: 1}, nil
}

func (s *Server) CancelPathCMD2Client(in *robotc.CancelPathCMDParam, ss robotc.BaseService_CancelPathCMD2ClientServer) error {
	for {
		select {
		case <-ss.Context().Done():
			return nil
		default:
			time.Sleep(time.Second * 10)
		}
	}
}

func (s *Server) CancelPathC2Srsp(context.Context, *robotc.RspCancelPathC2S) (*robotc.ReqCancelPathS2C, error) {
	return &robotc.ReqCancelPathS2C{NVoid: 1}, nil
}

func (s *Server) SetPathPointCMD2Client(in *robotc.SetPathPointCMDParam, ss robotc.BaseService_SetPathPointCMD2ClientServer) error {
	for {
		select {
		case <-ss.Context().Done():
			return nil
		default:
			time.Sleep(time.Second * 10)
		}
	}
}

func (s *Server) SetPathPointC2Srsp(context.Context, *robotc.RspSetPathPointC2S) (*robotc.ReqSetPathPointS2C, error) {
	return &robotc.ReqSetPathPointS2C{NVoid: 1}, nil
}

func (s *Server) GetVirtualWallList2Server(context.Context, *robotc.ReqDDRVLNMapEx) (*robotc.RspVirtualWallList, error) {
	return &robotc.RspVirtualWallList{NVoid: 1}, nil
}

func (s *Server) AddVirtualWall2Client(in *robotc.AddVirtualWallCMDParam, ss robotc.BaseService_AddVirtualWall2ClientServer) error {
	for {
		select {
		case <-ss.Context().Done():
			return nil
		default:
			time.Sleep(time.Second * 10)
		}
	}
}

func (s *Server) AddVirtualWallC2Srsp(context.Context, *robotc.RspAddVirtualWall2ClientC2S) (*robotc.ReqAddVirtualWall2ClientS2C, error) {
	return &robotc.ReqAddVirtualWall2ClientS2C{NVoid: 1}, nil
}

func (s *Server) DeleteVirtualWall2Client(in *robotc.DeleteVirtualWallCMDParam, ss robotc.BaseService_DeleteVirtualWall2ClientServer) error {
	for {
		select {
		case <-ss.Context().Done():
			return nil
		default:
			time.Sleep(time.Second * 10)
		}
	}
}

func (s *Server) DeleteVirtualWallC2Srsp(context.Context, *robotc.RspDeleteVirtualWall2ClientC2S) (*robotc.ReqDeleteVirtualWall2ClientS2C, error) {
	return &robotc.ReqDeleteVirtualWall2ClientS2C{NVoid: 1}, nil
}

func (s *Server) GetTaskList2Server(context.Context, *robotc.ReqDDRVLNMapEx) (*robotc.RspTaskList, error) {
	return &robotc.RspTaskList{NVoid: 1}, nil
}

func (s *Server) CreateTaskCMD2Client(in *robotc.CreateTaskCMDParam, ss robotc.BaseService_CreateTaskCMD2ClientServer) error {
	for {
		select {
		case <-ss.Context().Done():
			return nil
		default:
			time.Sleep(time.Second * 10)
		}
	}
}

func (s *Server) CreateTaskCMDC2Srsp(context.Context, *robotc.RspCreateTaskC2S) (*robotc.ReqCreateTaskS2C, error) {
	return &robotc.ReqCreateTaskS2C{NVoid: 1}, nil
}

func (s *Server) ModifyTaskParaCMD2Client(in *robotc.ModifyTaskParaCMDParam, ss robotc.BaseService_ModifyTaskParaCMD2ClientServer) error {
	for {
		select {
		case <-ss.Context().Done():
			return nil
		default:
			time.Sleep(time.Second * 10)
		}
	}
}

func (s *Server) ModifyTaskParaCMDC2Srsp(context.Context, *robotc.RspModifyTaskParaC2S) (*robotc.ReqModifyTaskParaS2C, error) {
	return &robotc.ReqModifyTaskParaS2C{NVoid: 1}, nil
}

func (s *Server) DeleteTaskCMDC2Srsp(context.Context, *robotc.RspDeleteTaskC2S) (*robotc.ReqDeleteMapS2C, error) {
	return &robotc.ReqDeleteMapS2C{NVoid: 1}, nil
}

func (s *Server) StartTaskC2Srsp(context.Context, *robotc.RspStartTask2ClientC2S) (*robotc.ReqStartTask2ClientS2C, error) {
	return &robotc.ReqStartTask2ClientS2C{NVoid: 1}, nil
}

func (s *Server) PauseCurrentTaskC2Srsp(context.Context, *robotc.RspPauseCurrentTask2ClientC2S) (*robotc.ReqPauseCurrentTask2ClientS2C, error) {
	return &robotc.ReqPauseCurrentTask2ClientS2C{NVoid: 1}, nil
}

func (s *Server) ResumeTaskC2Srsp(context.Context, *robotc.RspResumeTask2ClientC2S) (*robotc.ReqResumeTask2ClientS2C, error) {
	return &robotc.ReqResumeTask2ClientS2C{NVoid: 1}, nil
}

func (s *Server) EndTaskC2Srsp(context.Context, *robotc.RspEndTask2ClientC2S) (*robotc.ReqEndTask2ClientS2C, error) {
	return &robotc.ReqEndTask2ClientS2C{NVoid: 1}, nil
}

func (s *Server) TaskEffectivenessC2Srsp(context.Context, *robotc.RspTaskEffectiveness2ClientC2S) (*robotc.ReqTaskEffectiveness2ClientS2C, error) {
	return &robotc.ReqTaskEffectiveness2ClientS2C{NVoid: 1}, nil
}

func (s *Server) RelocationC2Srsp(context.Context, *robotc.RspRelocation2ClientC2S) (*robotc.ReqRelocation2ClientS2C, error) {
	return &robotc.ReqRelocation2ClientS2C{NVoid: 1}, nil
}

func (s *Server) PoseRelocationC2Srsp(context.Context, *robotc.RspPoseRelocation2ClientC2S) (*robotc.ReqPoseRelocation2ClientS2C, error) {
	return &robotc.ReqPoseRelocation2ClientS2C{NVoid: 1}, nil
}

func (s *Server) ShutdownC2Srsp(context.Context, *robotc.RspShutdown2ClientC2S) (*robotc.ReqShutdown2ClientS2C, error) {
	return &robotc.ReqShutdown2ClientS2C{NVoid: 1}, nil
}

func (s *Server) SetABTaskSpin2Client(in *robotc.SetABTaskSpinCMDParam, ss robotc.BaseService_SetABTaskSpin2ClientServer) error {
	for {
		select {
		case <-ss.Context().Done():
			return nil
		default:
			time.Sleep(time.Second * 10)
		}
	}
}

func (s *Server) SetABTaskSpinC2Srsp(context.Context, *robotc.RspSetABTaskSpin2ClientC2S) (*robotc.ReqSetABTaskSpin2ClientS2C, error) {
	return &robotc.ReqSetABTaskSpin2ClientS2C{NVoid: 1}, nil
}

func (s *Server) BackToInitPoint2Client(in *robotc.BackToInitPointCMDParam, ss robotc.BaseService_BackToInitPoint2ClientServer) error {
	for {
		select {
		case <-ss.Context().Done():
			return nil
		default:
			time.Sleep(time.Second * 10)
		}
	}
}

func (s *Server) BackToInitPointC2Srsp(context.Context, *robotc.RspBackToInitPoint2ClientC2S) (*robotc.ReqBackToInitPoint2ClientS2C, error) {
	return &robotc.ReqBackToInitPoint2ClientS2C{NVoid: 1}, nil
}

func (s *Server) PlayTTS2Client(in *robotc.PlayTTSCMDParam, ss robotc.BaseService_PlayTTS2ClientServer) error {
	for {
		select {
		case <-ss.Context().Done():
			return nil
		default:
			time.Sleep(time.Second * 10)
		}
	}
}

func (s *Server) PlayTTSC2Srsp(context.Context, *robotc.RspPlayTTS2ClientC2S) (*robotc.ReqPlayTTS2ClientS2C, error) {
	return &robotc.ReqPlayTTS2ClientS2C{NVoid: 1}, nil
}

func (s *Server) BaseStatusEx2Server(context.Context, *robotc.NotifyBaseStatusEx) (*robotc.RspMsg, error) {
	return &robotc.RspMsg{Ret: ""}, nil
}

func (s *Server) MapList2Server(context.Context, *robotc.NotifyMapListMsg) (*robotc.RspMapListMsg, error) {
	return &robotc.RspMapListMsg{NVoid: 1}, nil
}

func (s *Server) RobotBaseStart2Server(context.Context, *robotc.NotifyTaskStart) (*robotc.RspTaskStart, error) {
	return &robotc.RspTaskStart{NVoid: 1}, nil
}

func (s *Server) GetSurviveInfo2Client(in *robotc.GetSurviveInfoCMDParam, ss robotc.BaseService_GetSurviveInfo2ClientServer) error {
	for {
		select {
		case <-ss.Context().Done():
			return nil
		default:
			time.Sleep(time.Second * 10)
		}
	}
}

func (s *Server) GetTaskRecordInfo2Client(in *robotc.GetTaskRecordInfoCMDParam, ss robotc.BaseService_GetTaskRecordInfo2ClientServer) error {
	for {
		select {
		case <-ss.Context().Done():
			return nil
		default:
			time.Sleep(time.Second * 10)
		}
	}
}

func (s *Server) GetDDRAlarmInfo2Client(in *robotc.GetDDRAlarmInfoCMDParam, ss robotc.BaseService_GetDDRAlarmInfo2ClientServer) error {
	for {
		select {
		case <-ss.Context().Done():
			return nil
		default:
			time.Sleep(time.Second * 10)
		}
	}
}

func (s *Server) PushFlowC2Srsp(context.Context, *robotc.RspPushFlow2ClientC2S) (*robotc.ReqPushFlow2ClientS2C, error) {
	return &robotc.ReqPushFlow2ClientS2C{NVoid: 1}, nil
}

func (s *Server) CleanSOSStatus2Client(in *robotc.CleanSOSStatusCMDParam, ss robotc.BaseService_CleanSOSStatus2ClientServer) error {
	for {
		select {
		case <-ss.Context().Done():
			return nil
		default:
			time.Sleep(time.Second * 10)
		}
	}
}

func (s *Server) CleanSOSStatusC2Srsp(context.Context, *robotc.RspCleanSOSStatus2ClientC2S) (*robotc.ReqCleanSOSStatus2ClientS2C, error) {
	return &robotc.ReqCleanSOSStatus2ClientS2C{NVoid: 1}, nil
}
